home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / freeWAIS-sf-1.1 / ir / docid.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-10  |  11.6 KB  |  422 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.
  4.  *
  5.  * these are the methods for the DocID struct
  6.  * -brewster
  7.  *
  8.  * $Log: docid.c,v $
  9.  * Revision 1.5  1995/01/10  16:57:51  pfeifer
  10.  * Now writes docids unencoded, if ASCII_ID is defined. The original
  11.  * version can be used by defining CRYPT_IDS (this is of no use).
  12.  *
  13.  * Revision 1.4  1994/09/07  13:29:22  pfeifer
  14.  * ctype is now included from cdialect.h after inclusion of string.h.
  15.  * Since ctype.h (the local version defines strcmp and friends, inclusion o
  16.  * of string.h after that caused probems
  17.  *
  18.  * Revision 1.3  1994/05/20  12:55:48  pfeifer
  19.  * beta
  20.  *
  21.  * Revision 1.2  1994/03/08  20:58:34  pfeifer
  22.  * Patchlevel 04
  23.  *
  24.  * Revision 1.1  1993/02/16  15:05:35  freewais
  25.  * Initial revision
  26.  *
  27.  * Revision 1.6  92/05/10  14:42:57  jonathan
  28.  * Made a little safer on NULL docid's and such.
  29.  * 
  30.  * Revision 1.5  92/04/01  17:07:25  jonathan
  31.  * Added copyDocID.
  32.  * 
  33.  * Revision 1.4  92/02/21  11:05:03  jonathan
  34.  * added RCSIdent
  35.  * 
  36.  * Revision 1.3  92/02/21  11:04:30  jonathan
  37.  * Added header, fixed $Log.
  38.  * 
  39.  * Revision 1.2  92/02/12  13:17:44  jonathan
  40.  * Added $Log so RCS will put the log message in the header
  41.  * 
  42. */
  43.  
  44. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  45.  
  46.  
  47. #ifndef lint
  48. static char *RCSid = "$Header: /usr/local/ls6/src+data/src/freeWAIS-sf/ir/RCS/docid.c,v 1.5 1995/01/10 16:57:51 pfeifer Exp $";
  49. #endif
  50.  
  51. #include "docid.h"
  52. #include "irfileio.h"
  53. #include "cutil.h"
  54. #include "cdialect.h"
  55.  
  56. #define TESTDOC(doc) if((doc) == NULL) return NULL
  57.  
  58. /*---------------------------------------------------------------------------*/
  59.  
  60. /* get the server slot */
  61. any* GetServer(doc)
  62. DocID* doc;
  63. {
  64.   TESTDOC(doc);
  65.   if(NULL != doc->distributorServer)
  66.     return(doc->distributorServer);
  67.   else return(doc->originalServer);
  68. }
  69.  
  70. /*---------------------------------------------------------------------------*/
  71.  
  72. any* GetDatabase(doc)
  73. DocID* doc;
  74. {
  75.   TESTDOC(doc);
  76.   if(NULL != doc->distributorDatabase)
  77.     return(doc->distributorDatabase);
  78.   else return(doc->originalDatabase);
  79. }
  80.  
  81. /*---------------------------------------------------------------------------*/
  82.  
  83. any* GetLocalID(doc)
  84. DocID* doc;
  85. {
  86.   TESTDOC(doc);
  87.   if(NULL != doc->distributorLocalID)
  88.     return(doc->distributorLocalID);
  89.   else return(doc->originalLocalID);
  90. }
  91.  
  92. /*---------------------------------------------------------------------------*/
  93.  
  94. long GetCopyrightDisposition(doc)
  95. DocID* doc;
  96. {
  97.   if(doc)
  98.     return(doc->copyrightDisposition);
  99.   else return 0;
  100. }
  101.  
  102. /*---------------------------------------------------------------------------*/
  103.  
  104. /* returns FALSE if it loses, TRUE if it wins */
  105. long ReadDocID(doc,file)
  106. DocID* doc;
  107. FILE* file;
  108. {
  109.   char temp_string[MAX_SYMBOL_SIZE];
  110.   if(FALSE == CheckStartOfStruct("doc-id", file)){
  111.     return(FALSE);
  112.   }
  113.   doc->originalServer = NULL;
  114.   doc->originalDatabase = NULL;
  115.   doc->originalLocalID = NULL;
  116.   doc->distributorServer = NULL;
  117.   doc->distributorDatabase = NULL;
  118.   doc->distributorLocalID = NULL;
  119.   doc->copyrightDisposition = COPY_WITHOUT_RESTRICTION;
  120.     
  121.   while(TRUE){
  122.     long result = ReadSymbol(temp_string, file, 
  123.                  (long)MAX_SYMBOL_SIZE);
  124.         
  125.     if(FALSE == result){ 
  126.       return(FALSE);
  127.     }
  128.     if(END_OF_STRUCT_OR_LIST == result){
  129.       break;
  130.     }
  131.     if(0 == strcmp(temp_string, ":original-server")){
  132.       any* an_any = (any*)s_malloc(sizeof(any));
  133.       ReadAny(an_any, file);
  134.       doc->originalServer = an_any;
  135.     }
  136.     else if(0 == strcmp(temp_string, ":original-database")){
  137.       any* an_any = (any*)s_malloc(sizeof(any));
  138.       ReadAny(an_any, file);
  139.       doc->originalDatabase = an_any;
  140.     }
  141.     else if(0 == strcmp(temp_string, ":original-local-id")){
  142.       any* an_any = (any*)s_malloc(sizeof(any));
  143.       ReadAny(an_any, file);
  144.       doc->originalLocalID = an_any;
  145.     }
  146.     else if(0 == strcmp(temp_string, ":distributor-server")){
  147.       any* an_any = (any*)s_malloc(sizeof(any));
  148.       ReadAny(an_any, file);
  149.       doc->distributorServer = an_any;
  150.     }
  151.     else if(0 == strcmp(temp_string, ":distributor-database")){
  152.       any* an_any = (any*)s_malloc(sizeof(any));
  153.       ReadAny(an_any, file);
  154.       doc->distributorDatabase = an_any;
  155.     }
  156.     else if(0 == strcmp(temp_string, ":distributor-local-id")){
  157.       any* an_any = (any*)s_malloc(sizeof(any));
  158.       ReadAny(an_any, file);
  159.       doc->distributorLocalID = an_any;
  160.     }
  161.     else if(0 == strcmp(temp_string, ":copyright-disposition"))
  162.       ReadLong(file,&doc->copyrightDisposition);
  163.     else{
  164.       SkipObject(file);
  165.     }
  166.   }
  167.   return(TRUE);
  168. }
  169.  
  170.  
  171. /*---------------------------------------------------------------------------*/
  172.  
  173. #ifdef CRYPT_IDS
  174. #define WriteAnySymbol(A,B,C) WriteSymbol(A,C); WriteAny(B,C)
  175. #else
  176. /* this is a local function, only used in WriteDocID() */
  177. static void WriteAnySymbol(str1,Any,file)
  178. char *str1;
  179. any* Any;
  180. FILE* file;
  181. {
  182. char outstr[MAXNAMLEN], str2[MAXNAMLEN];
  183. int i;
  184.  
  185. #ifdef ASCII_ID
  186.   for(i=0; i<=Any->size; i++) {
  187.     str2[i] = Any->bytes[i];
  188.     }
  189. #ifdef ASCII_ID_TEST
  190.   fprintf(stderr,"WriteAnySymbol():'%s' '%s'\n", str1, str2);
  191.   fflush(stderr);
  192. #endif
  193.   sprintf(outstr,"%s %s ", str1, str2);
  194. #else
  195.   strcpy(outstr, str1);
  196. #endif
  197.   WriteSymbol(outstr, file);
  198.   WriteAny(Any, file);
  199. }
  200. #endif /* CRYPT_IDS */
  201.  
  202. /* this writes a CDocID to a stream */
  203. long WriteDocID(doc,file)
  204. DocID* doc;
  205. FILE* file;
  206. {
  207.   WriteNewline(file);
  208.   WriteStartOfStruct("doc-id", file);
  209.   if (NULL != doc->originalServer){
  210.     WriteNewline(file);
  211.     WriteAnySymbol(":original-server", doc->originalServer, file);
  212.   }
  213.   if (NULL != doc->originalDatabase){
  214.     WriteNewline(file);
  215.     WriteAnySymbol(":original-database", doc->originalDatabase, file);
  216.   }
  217.   if (NULL != doc->originalLocalID){
  218.     WriteNewline(file);
  219.     WriteAnySymbol(":original-local-id", doc->originalLocalID, file);
  220.   }
  221.   if (NULL != doc->distributorServer){
  222.     WriteNewline(file);
  223.     WriteAnySymbol(":distributor-server", doc->distributorServer, file);
  224.   }
  225.   if (NULL != doc->distributorDatabase){
  226.     WriteNewline(file);
  227.     WriteAnySymbol(":distributor-database", doc->distributorDatabase, file);
  228.   }
  229.   if (NULL != doc->distributorLocalID){
  230.     WriteNewline(file);
  231.     WriteAnySymbol(":distributor-local-id", doc->distributorLocalID, file);
  232.   }
  233.   WriteNewline(file);
  234.   WriteSymbol(":copyright-disposition", file);
  235.   WriteLong(doc->copyrightDisposition, file);
  236.   return(WriteEndOfStruct(file));
  237. }
  238.  
  239. /*---------------------------------------------------------------------------*/
  240.  
  241.     static Boolean safeCmp _AP((any* a1,any* a2));
  242.  
  243.     static Boolean safeCmp(a1,a2)
  244.         any* a1;
  245.         any* a2;
  246.         {
  247.         /* compare 2 any's, either of which may be NULL */
  248.         if (a1 == NULL && a2 == NULL)
  249.               return(true);
  250.         else if (a1 == NULL || a2 == NULL)
  251.               return(false);
  252.         else if (a1->size != a2->size)
  253.               return(false);
  254.         else if (memcmp(a1->bytes,a2->bytes,(size_t)a1->size) == 0)
  255.               return(true);
  256.         else
  257.             return(false);
  258.         }
  259.  
  260. /*---------------------------------------------------------------------------*/
  261.  
  262. Boolean cmpDocIDs(d1,d2)
  263. DocID* d1;
  264. DocID* d2;
  265. {
  266.   if (safeCmp(d1->originalServer,d2->originalServer) &&
  267.       safeCmp(d1->originalDatabase,d2->originalDatabase) &&
  268.       safeCmp(d1->originalLocalID,d2->originalLocalID) &&
  269.       safeCmp(d1->distributorServer,d2->distributorServer) &&
  270.       safeCmp(d1->distributorDatabase,d2->distributorDatabase) &&
  271.       safeCmp(d1->distributorLocalID,d2->distributorLocalID) &&
  272.       d1->copyrightDisposition == d2->copyrightDisposition)
  273.     return(true);
  274.   else
  275.     return(false); 
  276. }
  277.     
  278. /*---------------------------------------------------------------------------*/
  279.  
  280. DocID* 
  281. makeDocID()
  282. {
  283.   return((DocID*)s_malloc((size_t)sizeof(DocID)));
  284. }
  285.  
  286. /*---------------------------------------------------------------------------*/
  287.  
  288. DocID*
  289. copyDocID(doc)
  290. DocID* doc;
  291. {
  292.   DocID* result = NULL;
  293.   if(doc != NULL && 
  294.      (result = makeDocID()) != NULL) {
  295.     result->originalServer = duplicateAny(doc->originalServer);
  296.     result->originalDatabase = duplicateAny(doc->originalDatabase);
  297.     result->originalLocalID = duplicateAny(doc->originalLocalID);
  298.     result->distributorServer = duplicateAny(doc->distributorServer);
  299.     result->distributorDatabase = duplicateAny(doc->distributorDatabase);
  300.     result->distributorLocalID = duplicateAny(doc->distributorLocalID);
  301.   }
  302.   return result;
  303. }
  304.  
  305. /*---------------------------------------------------------------------------*/
  306.  
  307. void freeDocID(doc)
  308. DocID* doc;
  309. {
  310.   if(doc) {
  311.     freeAny(doc->originalServer);
  312.     freeAny(doc->originalDatabase);
  313.     freeAny(doc->originalLocalID);
  314.     freeAny(doc->distributorServer);
  315.     freeAny(doc->distributorDatabase);
  316.     freeAny(doc->distributorLocalID);
  317.     s_free(doc);
  318.   }
  319. }
  320.  
  321. /*---------------------------------------------------------------------------*/
  322.  
  323. #define DT_OriginalServer     (data_tag)1
  324. #define DT_OriginalDatabase     (data_tag)2
  325. #define DT_OriginalLocalID    (data_tag)3
  326. #define DT_DistributorServer    (data_tag)4
  327. #define DT_DistributorDatabase    (data_tag)5
  328. #define DT_DistributorLocalID    (data_tag)6
  329. #define DT_CopyrightDispostion    (data_tag)7
  330.  
  331. DocID*
  332. docIDFromAny(rawDocID)
  333. any* rawDocID;
  334. /* read from a z3950 docid to a docid structure */
  335. {
  336.   DocID* docID;
  337.   char* buf;
  338.   
  339.   TESTDOC(rawDocID);
  340.  
  341.   buf = rawDocID->bytes;
  342.   docID = makeDocID();
  343.   while ((buf - rawDocID->bytes) < rawDocID->size)
  344.     { data_tag tag = peekTag(buf);
  345.       switch (tag)
  346.     { case DT_OriginalServer:
  347.         buf = readAny(&(docID->originalServer),buf);
  348.         break;
  349.       case DT_OriginalDatabase:
  350.         buf = readAny(&(docID->originalDatabase),buf);
  351.         break;
  352.       case DT_OriginalLocalID:
  353.         buf = readAny(&(docID->originalLocalID),buf);
  354.         break;
  355.       case DT_DistributorServer:
  356.         buf = readAny(&(docID->distributorServer),buf);
  357.         break;
  358.       case DT_DistributorDatabase:
  359.         buf = readAny(&(docID->distributorDatabase),buf);
  360.         break;
  361.       case DT_DistributorLocalID:
  362.         buf = readAny(&(docID->distributorLocalID),buf);
  363.         break;
  364.       case DT_CopyrightDispostion:
  365.         buf = readNum(&(docID->copyrightDisposition),buf);
  366.         break;
  367.       default:
  368.         freeDocID(docID);
  369.         return(NULL);
  370.       };
  371.     }
  372.   
  373.   return(docID);
  374. }
  375.  
  376. /*---------------------------------------------------------------------------*/
  377.  
  378. any*
  379. anyFromDocID(docID)
  380. DocID* docID;
  381. /* write a docid structure to a buffer in z3950 format */
  382. {
  383.   any* rawDocID = NULL;
  384.   char* buf = NULL;
  385.   char* data = NULL;
  386.   long size,bytesLeft;
  387.   
  388.   if (docID == NULL)
  389.     return(NULL);
  390.     
  391.   size = writtenAnySize(DT_OriginalServer,docID->originalServer);
  392.   size += writtenAnySize(DT_OriginalDatabase,docID->originalDatabase);
  393.   size += writtenAnySize(DT_OriginalLocalID,docID->originalLocalID);
  394.   size += writtenAnySize(DT_DistributorServer,docID->distributorServer);
  395.   size += writtenAnySize(DT_DistributorDatabase,docID->distributorDatabase);
  396.   size += writtenAnySize(DT_DistributorLocalID,docID->distributorLocalID);
  397.   size += writtenNumSize(DT_CopyrightDispostion,docID->copyrightDisposition);
  398.   
  399.   data = s_malloc((size_t)(sizeof(char) * size));
  400.   
  401.   buf = data;
  402.   bytesLeft = size;
  403.   
  404.   buf = writeAny(docID->originalServer,DT_OriginalServer,buf,&bytesLeft);
  405.   buf = writeAny(docID->originalDatabase,DT_OriginalDatabase,buf,&bytesLeft);
  406.   buf = writeAny(docID->originalLocalID,DT_OriginalLocalID,buf,&bytesLeft);
  407.   buf = writeAny(docID->distributorServer,DT_DistributorServer,buf,
  408.                  &bytesLeft);
  409.   buf = writeAny(docID->distributorDatabase,DT_DistributorDatabase,
  410.                  buf,&bytesLeft);
  411.   buf = writeAny(docID->distributorLocalID,DT_DistributorLocalID,buf,
  412.                  &bytesLeft);
  413.   buf = writeNum(docID->copyrightDisposition,DT_CopyrightDispostion,
  414.                  buf,&bytesLeft);
  415.   
  416.   rawDocID = makeAny(size,data);
  417.   
  418.   return(rawDocID);
  419. }
  420.  
  421. /*---------------------------------------------------------------------------*/
  422.